extension YLList<E> on List<E> {
  List<E> copy({bool growable = true}) {
    return List<E>.from(this, growable: growable);
  }

  List<dynamic> sortAse() {
    List<dynamic> list = this;
    list.sort((a, b) => a.compareTo(b));
    return list;
  }

  List<E> trim() {
    List<E> list = this;
    if (list.isEmpty) return list;
    list = removeNull(list);
    return list;
  }

  void replace(dynamic A, dynamic B) {
    List<dynamic> list = this;
    int index = list.indexOf(A);
    this[index] = B;
  }

  void replaceWhere(bool Function(E) predicate, E newValue) {
    List<E> list = this;
    int index = list.indexWhere(predicate);
    if (index >= 0) {
      this[index] = newValue;
    }
  }

  List<T> insertInterval<T>(T intervalElement) {
    List<T> list = this as List<T>;

    // 如果原列表为空，直接返回它
    if (list.isEmpty) return list;

    // 创建一个新的列表来存放结果
    List<T> resultList = [];
    // 遍历原列表
    for (int i = 0; i < list.length; i++) {
      // 将当前元素添加到结果列表中
      resultList.add(list[i]);
      // 如果不是最后一个元素，则在之后插入间隔元素
      if (i != list.length - 1) {
        resultList.add(intervalElement);
      }
    }
    return resultList;
  }

  dynamic removeNull(dynamic params) {
    if (params is Map) {
      final filteredMap = {};
      params.forEach((key, value) {
        final processedValue = removeNull(value); // 递归处理嵌套结构
        if (processedValue != null) {
          filteredMap[key] = processedValue;
        }
      });
      return filteredMap; // 可选：移除空 Map
    } else if (params is List) {
      final filteredList = [];
      if (params.isNotEmpty) {
        for (var item in params) {
          final processedItem = removeNull(item); // 递归处理嵌套结构
          if (processedItem != null) {
            filteredList.add(processedItem);
          }
        }
      }

      return filteredList; // 可选：移除空 List
    }
    return params; // 非集合类型直接返回（若为 null 则被上层过滤）
  }
}
